package com.shiguiwu.springboot3.rockectmq.controller;

import com.shiguiwu.springboot3.util.R;
import lombok.extern.slf4j.Slf4j;
import org.apache.rocketmq.client.producer.SendCallback;
import org.apache.rocketmq.client.producer.SendResult;
import org.apache.rocketmq.client.producer.SendStatus;
import org.apache.rocketmq.spring.core.RocketMQTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.messaging.Message;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

/**
 * @description: 消息
 * @author: stone
 * @date: Created by 2023/11/11 18:09
 * @version: 1.0.0
 * @pakeage: com.shiguiwu.springboot3.message.rockectmq.controller
 * <p>
 * <p>
 * * 基本消息样例
 * * 1,同步消息：这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。
 * * 2,异步消息：用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。
 * * 3,单向发送消息：这种方式主要用在不关心发送结果的场景，例如日志发送。
 */
@Slf4j
@RestController
@RequestMapping("/rocketmq")
public class RocketMQController {


    @Autowired
    RocketMQTemplate rocketMQTemplate;

    @GetMapping("/send")
    public R<String> send(@RequestParam(defaultValue = "string-topic") String topic
            , @RequestParam(value = "msg") String msg) {
        log.info("开始发送...");

        Message<String> message = MessageBuilder.withPayload(msg).build();
        rocketMQTemplate.send(topic, message);

        log.info("已发送...");
        return R.ok("发送成功！");
    }


    /**
     * 同步消息: 这种可靠性同步地发送方式使用的比较广泛，比如：重要的消息通知，短信通知。
     */
    @GetMapping("/sync")
    public R<SendResult> sync(@RequestParam(defaultValue = "string-topic") String topic
            , @RequestParam(value = "msg") String msg) {

        SendResult sendResult = rocketMQTemplate.syncSend(topic, msg);
        if (sendResult.getSendStatus().equals(SendStatus.SEND_OK)) {
            return R.ok(sendResult);
        }
        return R.failed("发生消息失败！！！");
    }

    /**
     * 异步消息:异步消息通常用在对响应时间敏感的业务场景，即发送端不能容忍长时间地等待Broker的响应。
     */
    @GetMapping("/async")
    public R<String> async(@RequestParam(defaultValue = "string-topic") String topic
            , @RequestParam(value = "msg") String msg) {

        rocketMQTemplate.asyncSend(topic, msg, new SendCallback() {
            // SendCallback接收异步返回结果的回调
            // 成功发送
            @Override
            public void onSuccess(SendResult sendResult) {
                log.info("异步发送 - 发送成功");
            }

            // 发送失败
            @Override
            public void onException(Throwable throwable) {
                log.info("异步发送 - 发送失败");
                throwable.printStackTrace();
            }
        });
        return R.ok("发送成功但是未必真的成功");
    }

    /**
     * 单向发送消息:这种方式主要用在不特别关心发送结果的场景，例如日志发送。
     */
    @GetMapping("/oneWay")
    public R<String> oneWay(@RequestParam(defaultValue = "string-topic") String topic
            , @RequestParam(value = "msg") String msg) {

        rocketMQTemplate.sendOneWay(topic, msg);
        log.info("单向发送-已发送...");

        return R.ok("发送成功");
    }


}
